home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / encodings / punycode.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  8KB  |  269 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. ''' Codec for the Punicode encoding, as specified in RFC 3492
  5.  
  6. Written by Martin v. L\xf6wis.
  7. '''
  8. import codecs
  9.  
  10. def segregate(str):
  11.     '''3.1 Basic code point segregation'''
  12.     base = []
  13.     extended = { }
  14.     for c in str:
  15.         if ord(c) < 128:
  16.             base.append(c)
  17.             continue
  18.         extended[c] = 1
  19.     
  20.     extended = extended.keys()
  21.     extended.sort()
  22.     return (''.join(base).encode('ascii'), extended)
  23.  
  24.  
  25. def selective_len(str, max):
  26.     '''Return the length of str, considering only characters below max.'''
  27.     res = 0
  28.     for c in str:
  29.         if ord(c) < max:
  30.             res += 1
  31.             continue
  32.     
  33.     return res
  34.  
  35.  
  36. def selective_find(str, char, index, pos):
  37.     '''Return a pair (index, pos), indicating the next occurrence of
  38.     char in str. index is the position of the character considering
  39.     only ordinals up to and including char, and pos is the position in
  40.     the full string. index/pos is the starting position in the full
  41.     string.'''
  42.     l = len(str)
  43.     while None:
  44.         pos += 1
  45.         if pos == l:
  46.             return (-1, -1)
  47.         
  48.         c = str[pos]
  49.         if c == char:
  50.             return (index + 1, pos)
  51.             continue
  52.         if c < char:
  53.             index += 1
  54.             continue
  55.         continue
  56.         return None
  57.  
  58.  
  59. def insertion_unsort(str, extended):
  60.     '''3.2 Insertion unsort coding'''
  61.     oldchar = 128
  62.     result = []
  63.     oldindex = -1
  64.     for c in extended:
  65.         index = pos = -1
  66.         char = ord(c)
  67.         curlen = selective_len(str, char)
  68.         delta = (curlen + 1) * (char - oldchar)
  69.         while None:
  70.             (index, pos) = selective_find(str, c, index, pos)
  71.             if index == -1:
  72.                 break
  73.             
  74.             delta += index - oldindex
  75.             oldindex = index
  76.             delta = 0
  77.             continue
  78.             oldchar = char
  79.     return result
  80.  
  81.  
  82. def T(j, bias):
  83.     res = 36 * (j + 1) - bias
  84.     if res < 1:
  85.         return 1
  86.     
  87.     if res > 26:
  88.         return 26
  89.     
  90.     return res
  91.  
  92. digits = 'abcdefghijklmnopqrstuvwxyz0123456789'
  93.  
  94. def generate_generalized_integer(N, bias):
  95.     '''3.3 Generalized variable-length integers'''
  96.     result = []
  97.     j = 0
  98.     while None:
  99.         t = T(j, bias)
  100.         if N < t:
  101.             result.append(digits[N])
  102.             return result
  103.         
  104.         N = (N - t) // (36 - t)
  105.         j += 1
  106.         continue
  107.         return None
  108.  
  109.  
  110. def adapt(delta, first, numchars):
  111.     if first:
  112.         delta //= 700
  113.     else:
  114.         delta //= 2
  115.     delta += delta // numchars
  116.     divisions = 0
  117.     while delta > 455:
  118.         delta = delta // 35
  119.         divisions += 36
  120.     bias = divisions + 36 * delta // (delta + 38)
  121.     return bias
  122.  
  123.  
  124. def generate_integers(baselen, deltas):
  125.     '''3.4 Bias adaptation'''
  126.     result = []
  127.     bias = 72
  128.     for points, delta in enumerate(deltas):
  129.         s = generate_generalized_integer(delta, bias)
  130.         result.extend(s)
  131.         bias = adapt(delta, points == 0, baselen + points + 1)
  132.     
  133.     return ''.join(result)
  134.  
  135.  
  136. def punycode_encode(text):
  137.     (base, extended) = segregate(text)
  138.     base = base.encode('ascii')
  139.     deltas = insertion_unsort(text, extended)
  140.     extended = generate_integers(len(base), deltas)
  141.     if base:
  142.         return base + '-' + extended
  143.     
  144.     return extended
  145.  
  146.  
  147. def decode_generalized_number(extended, extpos, bias, errors):
  148.     '''3.3 Generalized variable-length integers'''
  149.     result = 0
  150.     w = 1
  151.     j = 0
  152.     while None:
  153.         
  154.         try:
  155.             char = ord(extended[extpos])
  156.         except IndexError:
  157.             if errors == 'strict':
  158.                 raise UnicodeError, 'incomplete punicode string'
  159.             
  160.             return (extpos + 1, None)
  161.  
  162.         extpos += 1
  163.         if char <= char:
  164.             pass
  165.         elif char <= 90:
  166.             digit = char - 65
  167.         elif char <= char:
  168.             pass
  169.         elif char <= 57:
  170.             digit = char - 22
  171.         elif errors == 'strict':
  172.             raise UnicodeError("Invalid extended code point '%s'" % extended[extpos])
  173.         else:
  174.             return (extpos, None)
  175.         t = T(j, bias)
  176.         result += digit * w
  177.         if digit < t:
  178.             return (extpos, result)
  179.         
  180.         w = w * (36 - t)
  181.         j += 1
  182.         continue
  183.         return None
  184.  
  185.  
  186. def insertion_sort(base, extended, errors):
  187.     '''3.2 Insertion unsort coding'''
  188.     char = 128
  189.     pos = -1
  190.     bias = 72
  191.     extpos = 0
  192.     while extpos < len(extended):
  193.         (newpos, delta) = decode_generalized_number(extended, extpos, bias, errors)
  194.         if delta is None:
  195.             return base
  196.         
  197.         pos += delta + 1
  198.         char += pos // (len(base) + 1)
  199.         if char > 1114111:
  200.             if errors == 'strict':
  201.                 raise UnicodeError, 'Invalid character U+%x' % char
  202.             
  203.             char = ord('?')
  204.         
  205.         pos = pos % (len(base) + 1)
  206.         base = base[:pos] + unichr(char) + base[pos:]
  207.         bias = adapt(delta, extpos == 0, len(base))
  208.         extpos = newpos
  209.     return base
  210.  
  211.  
  212. def punycode_decode(text, errors):
  213.     pos = text.rfind('-')
  214.     if pos == -1:
  215.         base = ''
  216.         extended = text
  217.     else:
  218.         base = text[:pos]
  219.         extended = text[pos + 1:]
  220.     base = unicode(base, 'ascii', errors)
  221.     extended = extended.upper()
  222.     return insertion_sort(base, extended, errors)
  223.  
  224.  
  225. class Codec(codecs.Codec):
  226.     
  227.     def encode(self, input, errors = 'strict'):
  228.         res = punycode_encode(input)
  229.         return (res, len(input))
  230.  
  231.     
  232.     def decode(self, input, errors = 'strict'):
  233.         if errors not in ('strict', 'replace', 'ignore'):
  234.             raise UnicodeError, 'Unsupported error handling ' + errors
  235.         
  236.         res = punycode_decode(input, errors)
  237.         return (res, len(input))
  238.  
  239.  
  240.  
  241. class IncrementalEncoder(codecs.IncrementalEncoder):
  242.     
  243.     def encode(self, input, final = False):
  244.         return punycode_encode(input)
  245.  
  246.  
  247.  
  248. class IncrementalDecoder(codecs.IncrementalDecoder):
  249.     
  250.     def decode(self, input, final = False):
  251.         if self.errors not in ('strict', 'replace', 'ignore'):
  252.             raise UnicodeError, 'Unsupported error handling ' + self.errors
  253.         
  254.         return punycode_decode(input, self.errors)
  255.  
  256.  
  257.  
  258. class StreamWriter(Codec, codecs.StreamWriter):
  259.     pass
  260.  
  261.  
  262. class StreamReader(Codec, codecs.StreamReader):
  263.     pass
  264.  
  265.  
  266. def getregentry():
  267.     return codecs.CodecInfo(name = 'punycode', encode = Codec().encode, decode = Codec().decode, incrementalencoder = IncrementalEncoder, incrementaldecoder = IncrementalDecoder, streamwriter = StreamWriter, streamreader = StreamReader)
  268.  
  269.